package yixin.utils.bazi.maps;

import java.util.HashMap;
import java.util.Map;

/**
 * 八字-神煞常量（常用）
 *
 * @author 善待
 */
public class BaZiShenShaMap {

    /**
     * 太极贵人（年干\日干+四柱地支为键）
     */
    public static final Map<String, String> TAI_JI_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年干\日干查四柱地支】甲见'子\午'。乙见'子\午'。丙见'卯\酉'。丁见'卯\酉'。戊见'辰\戌\丑\未'。己见'辰\戌\丑\未'。庚见'寅\亥'。辛见'寅\亥'。壬见'巳\申'。癸见'巳\申'

            二、详解：
                年干\日干是甲，并且四柱地支有子\午
                年干\日干是乙，并且四柱地支有子\午
                年干\日干是丙，并且四柱地支有卯\酉
                年干\日干是丁，并且四柱地支有卯\酉
                年干\日干是戊，并且四柱地支有辰\戌\丑\未
                年干\日干是己，并且四柱地支有辰\戌\丑\未
                年干\日干是庚，并且四柱地支有寅\亥
                年干\日干是辛，并且四柱地支有寅\亥
                年干\日干是壬，并且四柱地支有巳\申
                年干\日干是癸，并且四柱地支有巳\申
         */
        {
            put("甲子", "太极贵人");
            put("甲午", "太极贵人");
            put("乙子", "太极贵人");
            put("乙午", "太极贵人");
            put("丙卯", "太极贵人");
            put("丙酉", "太极贵人");
            put("丁卯", "太极贵人");
            put("丁酉", "太极贵人");
            put("戊辰", "太极贵人");
            put("戊戌", "太极贵人");
            put("戊丑", "太极贵人");
            put("戊未", "太极贵人");
            put("己辰", "太极贵人");
            put("己戌", "太极贵人");
            put("己丑", "太极贵人");
            put("己未", "太极贵人");
            put("庚寅", "太极贵人");
            put("庚亥", "太极贵人");
            put("辛寅", "太极贵人");
            put("辛亥", "太极贵人");
            put("壬巳", "太极贵人");
            put("壬申", "太极贵人");
            put("癸巳", "太极贵人");
            put("癸申", "太极贵人");
        }
    };

    /**
     * 天乙贵人（年干\日干+四柱地支为键）
     */
    public static final Map<String, String> TIAN_YI_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年干\日干查四柱地支】甲见'丑\未'。乙见'子\申'。丙见'酉\亥'。丁见'酉\亥'。戊见'丑\未'。己见'子\申'。庚见'丑\未'。辛见'寅\午'。壬见'卯\巳'。癸见'卯\巳'

            二、详解：
                年干\日干是甲，并且四柱地支有丑\未
                年干\日干是乙，并且四柱地支有子\申
                年干\日干是丙，并且四柱地支有酉\亥
                年干\日干是丁，并且四柱地支有酉\亥
                年干\日干是戊，并且四柱地支有丑\未
                年干\日干是己，并且四柱地支有子\申
                年干\日干是庚，并且四柱地支有丑\未
                年干\日干是辛，并且四柱地支有寅\午
                年干\日干是壬，并且四柱地支有卯\巳
                年干\日干是癸，并且四柱地支有卯\巳
         */
        {
            put("甲丑", "天乙贵人");
            put("甲未", "天乙贵人");
            put("乙子", "天乙贵人");
            put("乙申", "天乙贵人");
            put("丙酉", "天乙贵人");
            put("丙亥", "天乙贵人");
            put("丁酉", "天乙贵人");
            put("丁亥", "天乙贵人");
            put("戊丑", "天乙贵人");
            put("戊未", "天乙贵人");
            put("己子", "天乙贵人");
            put("己申", "天乙贵人");
            put("庚丑", "天乙贵人");
            put("庚未", "天乙贵人");
            put("辛寅", "天乙贵人");
            put("辛午", "天乙贵人");
            put("壬卯", "天乙贵人");
            put("壬巳", "天乙贵人");
            put("癸卯", "天乙贵人");
            put("癸巳", "天乙贵人");
        }
    };

    /**
     * 福星贵人（年干\日干+四柱地支为键）
     */
    public static final Map<String, String> FU_XING_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年干\日干查四柱地支】甲见'子\寅'。乙见'丑\卯'。丙见'子\寅'。丁见'亥'。戊见'申'。己见'未'。庚见'午'。辛见'巳'。壬见'辰'。癸见'丑\卯'

            二、详解：
                年干\日干是甲，并且四柱地支有子\寅
                年干\日干是乙，并且四柱地支有丑\卯
                年干\日干是丙，并且四柱地支有子\寅
                年干\日干是丁，并且四柱地支有亥
                年干\日干是戊，并且四柱地支有申
                年干\日干是己，并且四柱地支有未
                年干\日干是庚，并且四柱地支有午
                年干\日干是辛，并且四柱地支有巳
                年干\日干是壬，并且四柱地支有辰
                年干\日干是癸，并且四柱地支有丑\卯
         */
        {
            put("甲子", "福星贵人");
            put("甲寅", "福星贵人");
            put("乙丑", "福星贵人");
            put("乙卯", "福星贵人");
            put("丙子", "福星贵人");
            put("丙寅", "福星贵人");
            put("丁亥", "福星贵人");
            put("戊申", "福星贵人");
            put("己未", "福星贵人");
            put("庚午", "福星贵人");
            put("辛巳", "福星贵人");
            put("壬辰", "福星贵人");
            put("癸丑", "福星贵人");
            put("癸卯", "福星贵人");
        }
    };

    /**
     * 文昌贵人（年干\日干+四柱地支为键）
     */
    public static final Map<String, String> WEN_CHANG_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年干\日干查四柱地支】甲见'巳'。乙见'午'。丙见'申'。丁见'酉'。戊见'申'。己见'酉'。庚见'亥'。辛见'子'。壬见'寅'。癸见'卯'

            二、详解：
                年干\日干是甲，并且四柱地支有巳
                年干\日干是乙，并且四柱地支有午
                年干\日干是丙，并且四柱地支有申
                年干\日干是丁，并且四柱地支有酉
                年干\日干是戊，并且四柱地支有申
                年干\日干是己，并且四柱地支有酉
                年干\日干是庚，并且四柱地支有亥
                年干\日干是辛，并且四柱地支有子
                年干\日干是壬，并且四柱地支有寅
                年干\日干是癸，并且四柱地支有卯
         */
        {
            put("甲巳", "文昌贵人");
            put("乙午", "文昌贵人");
            put("丙申", "文昌贵人");
            put("丁酉", "文昌贵人");
            put("戊申", "文昌贵人");
            put("己酉", "文昌贵人");
            put("庚亥", "文昌贵人");
            put("辛子", "文昌贵人");
            put("壬寅", "文昌贵人");
            put("癸卯", "文昌贵人");
        }
    };

    /**
     * 天厨贵人（年干\日干+四柱地支为键）
     */
    public static final Map<String, String> TIAN_CHU_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年干\日干查四柱地支】甲见'巳'。乙见'午'。丙见'巳'。丁见'午'。戊见'申'。己见'酉'。庚见'亥'。辛见'子'。壬见'寅'。癸见'卯'

            二、详解：
                年干\日干是甲，并且四柱地支有巳
                年干\日干是乙，并且四柱地支有午
                年干\日干是丙，并且四柱地支有巳
                年干\日干是丁，并且四柱地支有午
                年干\日干是戊，并且四柱地支有申
                年干\日干是己，并且四柱地支有酉
                年干\日干是庚，并且四柱地支有亥
                年干\日干是辛，并且四柱地支有子
                年干\日干是壬，并且四柱地支有寅
                年干\日干是癸，并且四柱地支有卯
         */
        {
            put("甲巳", "天厨贵人");
            put("乙午", "天厨贵人");
            put("丙巳", "天厨贵人");
            put("丁午", "天厨贵人");
            put("戊申", "天厨贵人");
            put("己酉", "天厨贵人");
            put("庚亥", "天厨贵人");
            put("辛子", "天厨贵人");
            put("壬寅", "天厨贵人");
            put("癸卯", "天厨贵人");
        }
    };

    /**
     * 国印（年干\日干+四柱地支为键）
     */
    public static final Map<String, String> GUO_YIN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年干\日干查四柱地支】甲见'戌'。乙见'亥'。丙见'丑'。丁见'寅'。戊见'丑'。己见'寅'。庚见'辰'。辛见'巳'。壬见'未'。癸见'申'

            二、详解：
                年干\日干是甲，并且四柱地支有戌
                年干\日干是乙，并且四柱地支有亥
                年干\日干是丙，并且四柱地支有丑
                年干\日干是丁，并且四柱地支有寅
                年干\日干是戊，并且四柱地支有丑
                年干\日干是己，并且四柱地支有寅
                年干\日干是庚，并且四柱地支有辰
                年干\日干是辛，并且四柱地支有巳
                年干\日干是壬，并且四柱地支有未
                年干\日干是癸，并且四柱地支有申
         */
        {
            put("甲戌", "国印");
            put("乙亥", "国印");
            put("丙丑", "国印");
            put("丁寅", "国印");
            put("戊丑", "国印");
            put("己寅", "国印");
            put("庚辰", "国印");
            put("辛巳", "国印");
            put("壬未", "国印");
            put("癸申", "国印");
        }
    };

    /**
     * 金舆（年干\日干+四柱地支为键）
     */
    public static final Map<String, String> JIN_YU = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年干\日干查四柱地支】甲见'辰'。乙见'巳'。丙见'未'。丁见'申'。戊见'未'。己见'申'。庚见'戌'。辛见'亥'。壬见'丑'。癸见'寅'

            二、详解：
                年干\日干是甲，并且四柱地支有辰
                年干\日干是乙，并且四柱地支有巳
                年干\日干是丙，并且四柱地支有未
                年干\日干是丁，并且四柱地支有申
                年干\日干是戊，并且四柱地支有未
                年干\日干是己，并且四柱地支有申
                年干\日干是庚，并且四柱地支有戌
                年干\日干是辛，并且四柱地支有亥
                年干\日干是壬，并且四柱地支有丑
                年干\日干是癸，并且四柱地支有寅
         */
        {
            put("甲辰", "金舆");
            put("乙巳", "金舆");
            put("丙未", "金舆");
            put("丁申", "金舆");
            put("戊未", "金舆");
            put("己申", "金舆");
            put("庚戌", "金舆");
            put("辛亥", "金舆");
            put("壬丑", "金舆");
            put("癸寅", "金舆");
        }
    };

    /**
     * 红艳煞（年干\日干+四柱地支为键）
     */
    public static final Map<String, String> HONG_YAN_SHA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年干\日干查四柱地支】甲见'午'。乙见'申'。丙见'寅'。丁见'未'。戊见'辰'。己见'辰'。庚见'戌'。辛见'酉'。壬见'子'。癸见'申'

            二、详解：
                日干是甲，并且四柱地支有午
                日干是乙，并且四柱地支有申
                日干是丙，并且四柱地支有寅
                日干是丁，并且四柱地支有未
                日干是戊，并且四柱地支有辰
                日干是己，并且四柱地支有辰
                日干是庚，并且四柱地支有戌
                日干是辛，并且四柱地支有酉
                日干是壬，并且四柱地支有子
                日干是癸，并且四柱地支有申
         */
        {
            put("甲午", "红艳煞");
            put("乙申", "红艳煞");
            put("丙寅", "红艳煞");
            put("丁未", "红艳煞");
            put("戊辰", "红艳煞");
            put("己辰", "红艳煞");
            put("庚戌", "红艳煞");
            put("辛酉", "红艳煞");
            put("壬子", "红艳煞");
            put("癸申", "红艳煞");
        }
    };

    /**
     * 羊刃（年干\日干+四柱地支为键）
     */
    public static final Map<String, String> YANG_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年干\日干查四柱地支】甲见'卯'。乙见'寅'。丙见'午'。丁见'巳'。戊见'午'。己见'巳'。庚见'酉'。辛见'申'。壬见'子'。癸见'亥'

            二、详解：
                日干是甲，并且四柱地支有卯
                日干是乙，并且四柱地支有寅
                日干是丙，并且四柱地支有午
                日干是丁，并且四柱地支有巳
                日干是戊，并且四柱地支有午
                日干是己，并且四柱地支有巳
                日干是庚，并且四柱地支有酉
                日干是辛，并且四柱地支有申
                日干是壬，并且四柱地支有子
                日干是癸，并且四柱地支有亥
         */
        {
            put("甲卯", "羊刃");
            put("乙寅", "羊刃");
            put("丙午", "羊刃");
            put("丁巳", "羊刃");
            put("戊午", "羊刃");
            put("己巳", "羊刃");
            put("庚酉", "羊刃");
            put("辛申", "羊刃");
            put("壬子", "羊刃");
            put("癸亥", "羊刃");
        }
    };

    /**
     * 飞刃（日干+四柱地支为键）
     */
    public static final Map<String, String> FEI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以日干查四柱地支】甲见'酉'。乙见'寅'。丙见'子'。丁见'亥'。戊见'子'。己见'亥'。庚见'卯'。辛见'寅'。壬见'午'。癸见'巳'

            二、详解：
                日干是甲，并且四柱地支有酉
                日干是乙，并且四柱地支有寅
                日干是丙，并且四柱地支有子
                日干是丁，并且四柱地支有亥
                日干是戊，并且四柱地支有子
                日干是己，并且四柱地支有亥
                日干是庚，并且四柱地支有卯
                日干是辛，并且四柱地支有寅
                日干是壬，并且四柱地支有午
                日干是癸，并且四柱地支有巳
         */
        {
            put("甲酉", "飞刃");
            put("乙寅", "飞刃");
            put("丙子", "飞刃");
            put("丁亥", "飞刃");
            put("戊子", "飞刃");
            put("己亥", "飞刃");
            put("庚卯", "飞刃");
            put("辛寅", "飞刃");
            put("壬午", "飞刃");
            put("癸巳", "飞刃");
        }
    };

    /**
     * 流霞（日干+四柱地支为键）
     */
    public static final Map<String, String> LIU_XIA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以日干查四柱地支】甲见'酉'。乙见'戌'。丙见'未'。丁见'申'。戊见'巳'。己见'午'。庚见'辰'。辛见'卯'。壬见'亥'。癸见'寅'

            二、详解：
                日干是甲，并且四柱地支有酉
                日干是乙，并且四柱地支有戌
                日干是丙，并且四柱地支有未
                日干是丁，并且四柱地支有申
                日干是戊，并且四柱地支有巳
                日干是己，并且四柱地支有午
                日干是庚，并且四柱地支有辰
                日干是辛，并且四柱地支有卯
                日干是壬，并且四柱地支有亥
                日干是癸，并且四柱地支有寅
         */
        {
            put("甲酉", "流霞");
            put("乙戌", "流霞");
            put("丙未", "流霞");
            put("丁申", "流霞");
            put("戊巳", "流霞");
            put("己午", "流霞");
            put("庚辰", "流霞");
            put("辛卯", "流霞");
            put("壬亥", "流霞");
            put("癸寅", "流霞");
        }
    };

    /**
     * 禄神（日干+四柱地支为键）
     */
    public static final Map<String, String> LU_SHEN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以日干查四柱地支】甲见'寅'。乙见'卯'。丙见'巳'。丁见'午'。戊见'巳'。己见'午'。庚见'申'。辛见'酉'。壬见'亥'。癸见'子'

            二、详解：
                日干是甲，并且四柱地支有寅
                日干是乙，并且四柱地支有卯
                日干是丙，并且四柱地支有巳
                日干是丁，并且四柱地支有午
                日干是戊，并且四柱地支有巳
                日干是己，并且四柱地支有午
                日干是庚，并且四柱地支有申
                日干是辛，并且四柱地支有酉
                日干是壬，并且四柱地支有亥
                日干是癸，并且四柱地支有子
         */
        {
            put("甲寅", "禄神");
            put("乙卯", "禄神");
            put("丙巳", "禄神");
            put("丁午", "禄神");
            put("戊巳", "禄神");
            put("己午", "禄神");
            put("庚申", "禄神");
            put("辛酉", "禄神");
            put("壬亥", "禄神");
            put("癸子", "禄神");
        }
    };

    /**
     * 驿马（年支\日支+其余地支为键）
     */
    public static final Map<String, String> YI_MA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支\日支查其余地支】子见'寅'。丑见'亥'。寅见'申'。卯见'巳'。辰见'寅'。巳见'亥'。午见'申'。未见'巳'。申见'寅'。酉见'亥'。戌见'申'。亥见'巳'

            二、详解：
                年支\日支是子，并且其余地支有寅
                年支\日支是丑，并且其余地支有亥
                年支\日支是寅，并且其余地支有申
                年支\日支是卯，并且其余地支有巳
                年支\日支是辰，并且其余地支有寅
                年支\日支是巳，并且其余地支有亥
                年支\日支是午，并且其余地支有申
                年支\日支是未，并且其余地支有巳
                年支\日支是申，并且其余地支有寅
                年支\日支是酉，并且其余地支有亥
                年支\日支是戌，并且其余地支有申
                年支\日支是亥，并且其余地支有巳
         */
        {
            put("子寅", "驿马");
            put("丑亥", "驿马");
            put("寅申", "驿马");
            put("卯巳", "驿马");
            put("辰寅", "驿马");
            put("巳亥", "驿马");
            put("午申", "驿马");
            put("未巳", "驿马");
            put("申寅", "驿马");
            put("酉亥", "驿马");
            put("戌申", "驿马");
            put("亥巳", "驿马");
        }
    };

    /**
     * 劫煞（年支\日支+其余地支为键）
     */
    public static final Map<String, String> JIE_SHA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支\日支查其余地支】子见'巳'。丑见'寅'。寅见'亥'。卯见'申'。辰见'巳'。巳见'寅'。午见'亥'。未见'申'。申见'巳'。酉见'寅'。戌见'亥'。亥见'申'

            二、详解：
                年支\日支是子，并且其余地支有巳
                年支\日支是丑，并且其余地支有寅
                年支\日支是寅，并且其余地支有亥
                年支\日支是卯，并且其余地支有申
                年支\日支是辰，并且其余地支有巳
                年支\日支是巳，并且其余地支有寅
                年支\日支是午，并且其余地支有亥
                年支\日支是未，并且其余地支有申
                年支\日支是申，并且其余地支有巳
                年支\日支是酉，并且其余地支有寅
                年支\日支是戌，并且其余地支有亥
                年支\日支是亥，并且其余地支有申
         */
        {
            put("子巳", "劫煞");
            put("丑寅", "劫煞");
            put("寅亥", "劫煞");
            put("卯申", "劫煞");
            put("辰巳", "劫煞");
            put("巳寅", "劫煞");
            put("午亥", "劫煞");
            put("未申", "劫煞");
            put("申巳", "劫煞");
            put("酉寅", "劫煞");
            put("戌亥", "劫煞");
            put("亥申", "劫煞");
        }
    };

    /**
     * 将星（年支\日支+其余地支为键）
     */
    public static final Map<String, String> JIANG_XING = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支\日支查其余地支】子见'子'。丑见'酉'。寅见'午'。卯见'卯'。辰见'子'。巳见'酉'。午见'午'。未见'卯'。申见'子'。酉见'酉'。戌见'午'。亥见'卯'

            二、详解：
                年支\日支是子，并且其余地支有子
                年支\日支是丑，并且其余地支有酉
                年支\日支是寅，并且其余地支有午
                年支\日支是卯，并且其余地支有卯
                年支\日支是辰，并且其余地支有子
                年支\日支是巳，并且其余地支有酉
                年支\日支是午，并且其余地支有午
                年支\日支是未，并且其余地支有卯
                年支\日支是申，并且其余地支有子
                年支\日支是酉，并且其余地支有酉
                年支\日支是戌，并且其余地支有午
                年支\日支是亥，并且其余地支有卯
         */
        {
            put("子子", "将星");
            put("丑酉", "将星");
            put("寅午", "将星");
            put("卯卯", "将星");
            put("辰子", "将星");
            put("巳酉", "将星");
            put("午午", "将星");
            put("未卯", "将星");
            put("申子", "将星");
            put("酉酉", "将星");
            put("戌午", "将星");
            put("亥卯", "将星");
        }
    };

    /**
     * 桃花（年支\日支+其余地支为键）
     */
    public static final Map<String, String> TAO_HUA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支\日支查其余地支】子见'酉'。丑见'午'。寅见'卯'。卯见'子'。辰见'酉'。巳见'午'。午见'卯'。未见'子'。申见'酉'。酉见'午'。戌见'卯'。亥见'子'

            二、详解：
                年支\日支是子，并且其余地支有酉
                年支\日支是丑，并且其余地支有午
                年支\日支是寅，并且其余地支有卯
                年支\日支是卯，并且其余地支有子
                年支\日支是辰，并且其余地支有酉
                年支\日支是巳，并且其余地支有午
                年支\日支是午，并且其余地支有卯
                年支\日支是未，并且其余地支有子
                年支\日支是申，并且其余地支有酉
                年支\日支是酉，并且其余地支有午
                年支\日支是戌，并且其余地支有卯
                年支\日支是亥，并且其余地支有子
         */
        {
            put("子酉", "桃花");
            put("丑午", "桃花");
            put("寅卯", "桃花");
            put("卯子", "桃花");
            put("辰酉", "桃花");
            put("巳午", "桃花");
            put("午卯", "桃花");
            put("未子", "桃花");
            put("申酉", "桃花");
            put("酉午", "桃花");
            put("戌卯", "桃花");
            put("亥子", "桃花");
        }
    };

    /**
     * 亡神（年支\日支+其余地支为键）
     */
    public static final Map<String, String> WANG_SHEN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支\日支查其余地支】子见'亥'。丑见'申'。寅见'巳'。卯见'寅'。辰见'亥'。巳见'申'。午见'巳'。未见'寅'。申见'亥'。酉见'申'。戌见'巳'。亥见'寅'

            二、详解：
                年支\日支是子，并且其余地支有亥
                年支\日支是丑，并且其余地支有申
                年支\日支是寅，并且其余地支有巳
                年支\日支是卯，并且其余地支有寅
                年支\日支是辰，并且其余地支有亥
                年支\日支是巳，并且其余地支有申
                年支\日支是午，并且其余地支有巳
                年支\日支是未，并且其余地支有寅
                年支\日支是申，并且其余地支有亥
                年支\日支是酉，并且其余地支有申
                年支\日支是戌，并且其余地支有巳
                年支\日支是亥，并且其余地支有寅
         */
        {
            put("子亥", "亡神");
            put("丑申", "亡神");
            put("寅巳", "亡神");
            put("卯寅", "亡神");
            put("辰亥", "亡神");
            put("巳申", "亡神");
            put("午巳", "亡神");
            put("未寅", "亡神");
            put("申亥", "亡神");
            put("酉申", "亡神");
            put("戌巳", "亡神");
            put("亥寅", "亡神");
        }
    };

    /**
     * 吊客（年支\日支+其余地支为键）
     */
    public static final Map<String, String> DIAO_KE = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支\日支查其余地支】子见'戌'。丑见'亥'。寅见'子'。卯见'丑'。辰见'寅'。巳见'卯'。午见'辰'。未见'巳'。申见'午'。酉见'未'。戌见'申'。亥见'酉'

            二、详解：
                年支\日支是子，并且其余地支有戌
                年支\日支是丑，并且其余地支有亥
                年支\日支是寅，并且其余地支有子
                年支\日支是卯，并且其余地支有丑
                年支\日支是辰，并且其余地支有寅
                年支\日支是巳，并且其余地支有卯
                年支\日支是午，并且其余地支有辰
                年支\日支是未，并且其余地支有巳
                年支\日支是申，并且其余地支有午
                年支\日支是酉，并且其余地支有未
                年支\日支是戌，并且其余地支有申
                年支\日支是亥，并且其余地支有酉
         */
        {
            put("子戌", "吊客");
            put("丑亥", "吊客");
            put("寅子", "吊客");
            put("卯丑", "吊客");
            put("辰寅", "吊客");
            put("巳卯", "吊客");
            put("午辰", "吊客");
            put("未巳", "吊客");
            put("申午", "吊客");
            put("酉未", "吊客");
            put("戌申", "吊客");
            put("亥酉", "吊客");
        }
    };

    /**
     * 披麻（年支\日支+其余地支为键）
     */
    public static final Map<String, String> PI_MA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支\日支查其余地支】子见'酉'。丑见'戌'。寅见'亥'。卯见'子'。辰见'丑'。巳见'寅'。午见'卯'。未见'辰'。申见'巳'。酉见'午'。戌见'未'。亥见'申'

            二、详解：
                年支\日支是子，并且其余地支有酉
                年支\日支是丑，并且其余地支有戌
                年支\日支是寅，并且其余地支有亥
                年支\日支是卯，并且其余地支有子
                年支\日支是辰，并且其余地支有丑
                年支\日支是巳，并且其余地支有寅
                年支\日支是午，并且其余地支有卯
                年支\日支是未，并且其余地支有辰
                年支\日支是申，并且其余地支有巳
                年支\日支是酉，并且其余地支有午
                年支\日支是戌，并且其余地支有未
                年支\日支是亥，并且其余地支有申
         */
        {
            put("子酉", "披麻");
            put("丑戌", "披麻");
            put("寅亥", "披麻");
            put("卯子", "披麻");
            put("辰丑", "披麻");
            put("巳寅", "披麻");
            put("午卯", "披麻");
            put("未辰", "披麻");
            put("申巳", "披麻");
            put("酉午", "披麻");
            put("戌未", "披麻");
            put("亥申", "披麻");
        }
    };

    /**
     * 天官贵人（年干+四柱地支为键）
     */
    public static final Map<String, String> TIAN_GUAN_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年干查四柱地支】甲见'未'。乙见'辰'。丙见'巳'。丁见'酉'。戊见'戌'。己见'卯'。庚见'丑'。辛见'申'。壬见'寅'。癸见'午'

            二、详解：
                年干是甲，并且四柱地支有未
                年干是乙，并且四柱地支有辰
                年干是丙，并且四柱地支有巳
                年干是丁，并且四柱地支有酉
                年干是戊，并且四柱地支有戌
                年干是己，并且四柱地支有卯
                年干是庚，并且四柱地支有丑
                年干是辛，并且四柱地支有申
                年干是壬，并且四柱地支有寅
                年干是癸，并且四柱地支有午
         */
        {
            put("甲未", "天官贵人");
            put("乙辰", "天官贵人");
            put("丙巳", "天官贵人");
            put("丁酉", "天官贵人");
            put("戊戌", "天官贵人");
            put("己卯", "天官贵人");
            put("庚丑", "天官贵人");
            put("辛申", "天官贵人");
            put("壬寅", "天官贵人");
            put("癸午", "天官贵人");
        }
    };

    /**
     * 天喜（年支+其余地支为键）
     */
    public static final Map<String, String> TIAN_XI = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支查其余地支】子见'酉'。丑见'申'。寅见'未'。卯见'午'。辰见'巳'。巳见'辰'。午见'卯'。未见'寅'。申见'丑'。酉见'子'。戌见'亥'。亥见'戌'

            二、详解：
                年支是子，并且其余地支有酉
                年支是丑，并且其余地支有申
                年支是寅，并且其余地支有未
                年支是卯，并且其余地支有午
                年支是辰，并且其余地支有巳
                年支是巳，并且其余地支有辰
                年支是午，并且其余地支有卯
                年支是未，并且其余地支有寅
                年支是申，并且其余地支有丑
                年支是酉，并且其余地支有子
                年支是戌，并且其余地支有亥
                年支是亥，并且其余地支有戌
         */
        {
            put("子酉", "天喜");
            put("丑申", "天喜");
            put("寅未", "天喜");
            put("卯午", "天喜");
            put("辰巳", "天喜");
            put("巳辰", "天喜");
            put("午卯", "天喜");
            put("未寅", "天喜");
            put("申丑", "天喜");
            put("酉子", "天喜");
            put("戌亥", "天喜");
            put("亥戌", "天喜");
        }
    };

    /**
     * 勾绞煞（年支+其余地支为键）
     */
    public static final Map<String, String> GOU_JIAO_SHA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支查其余地支】子见'卯'。丑见'辰'。寅见'巳'。卯见'午'。辰见'未'。巳见'申'。午见'酉'。未见'戌'。申见'亥'。酉见'子'。戌见'丑'。亥见'寅'

            二、详解：
                年支是子，并且其余地支有卯
                年支是丑，并且其余地支有辰
                年支是寅，并且其余地支有巳
                年支是卯，并且其余地支有午
                年支是辰，并且其余地支有未
                年支是巳，并且其余地支有申
                年支是午，并且其余地支有酉
                年支是未，并且其余地支有戌
                年支是申，并且其余地支有亥
                年支是酉，并且其余地支有子
                年支是戌，并且其余地支有丑
                年支是亥，并且其余地支有寅
         */
        {
            put("子卯", "勾绞煞");
            put("丑辰", "勾绞煞");
            put("寅巳", "勾绞煞");
            put("卯午", "勾绞煞");
            put("辰未", "勾绞煞");
            put("巳申", "勾绞煞");
            put("午酉", "勾绞煞");
            put("未戌", "勾绞煞");
            put("申亥", "勾绞煞");
            put("酉子", "勾绞煞");
            put("戌丑", "勾绞煞");
            put("亥寅", "勾绞煞");
        }
    };

    /**
     * 红鸾（年支+其余地支为键）
     */
    public static final Map<String, String> HONG_LUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支查其余地支】子见'卯'。丑见'寅'。寅见'丑'。卯见'子'。辰见'亥'。巳见'戌'。午见'酉'。未见'申'。申见'未'。酉见'午'。戌见'巳'。亥见'辰'

            二、详解：
                年支是子，并且其余地支有卯
                年支是丑，并且其余地支有寅
                年支是寅，并且其余地支有丑
                年支是卯，并且其余地支有子
                年支是辰，并且其余地支有亥
                年支是巳，并且其余地支有戌
                年支是午，并且其余地支有酉
                年支是未，并且其余地支有申
                年支是申，并且其余地支有未
                年支是酉，并且其余地支有午
                年支是戌，并且其余地支有巳
                年支是亥，并且其余地支有辰
         */
        {
            put("子卯", "红鸾");
            put("丑寅", "红鸾");
            put("寅丑", "红鸾");
            put("卯子", "红鸾");
            put("辰亥", "红鸾");
            put("巳戌", "红鸾");
            put("午酉", "红鸾");
            put("未申", "红鸾");
            put("申未", "红鸾");
            put("酉午", "红鸾");
            put("戌巳", "红鸾");
            put("亥辰", "红鸾");
        }
    };

    /**
     * 丧门（年支+其余地支为键）
     */
    public static final Map<String, String> SANG_MEN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支查其余地支】子见'寅'。丑见'卯'。寅见'辰'。卯见'巳'。辰见'午'。巳见'未'。午见'申'。未见'酉'。申见'戌'。酉见'寅'。戌见'卯'。亥见'辰'

            二、详解：
                年支是子，并且其余地支有寅
                年支是丑，并且其余地支有卯
                年支是寅，并且其余地支有辰
                年支是卯，并且其余地支有巳
                年支是辰，并且其余地支有午
                年支是巳，并且其余地支有未
                年支是午，并且其余地支有申
                年支是未，并且其余地支有酉
                年支是申，并且其余地支有戌
                年支是酉，并且其余地支有寅
                年支是戌，并且其余地支有卯
                年支是亥，并且其余地支有辰
         */
        {
            put("子寅", "丧门");
            put("丑卯", "丧门");
            put("寅辰", "丧门");
            put("卯巳", "丧门");
            put("辰午", "丧门");
            put("巳未", "丧门");
            put("午申", "丧门");
            put("未酉", "丧门");
            put("申戌", "丧门");
            put("酉寅", "丧门");
            put("戌卯", "丧门");
            put("亥辰", "丧门");
        }
    };

    /**
     * 灾煞（年支+其余地支为键）
     */
    public static final Map<String, String> ZAI_SHA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支查其余地支】子见'午'。丑见'卯'。寅见'子'。卯见'酉'。辰见'午'。巳见'卯'。午见'子'。未见'酉'。申见'午'。酉见'卯'。戌见'子'。亥见'酉'

            二、详解：
                年支是子，并且其余地支有午
                年支是丑，并且其余地支有卯
                年支是寅，并且其余地支有子
                年支是卯，并且其余地支有酉
                年支是辰，并且其余地支有午
                年支是巳，并且其余地支有卯
                年支是午，并且其余地支有子
                年支是未，并且其余地支有酉
                年支是申，并且其余地支有午
                年支是酉，并且其余地支有卯
                年支是戌，并且其余地支有子
                年支是亥，并且其余地支有酉
         */
        {
            put("子午", "灾煞");
            put("丑卯", "灾煞");
            put("寅子", "灾煞");
            put("卯酉", "灾煞");
            put("辰午", "灾煞");
            put("巳卯", "灾煞");
            put("午子", "灾煞");
            put("未酉", "灾煞");
            put("申午", "灾煞");
            put("酉卯", "灾煞");
            put("戌子", "灾煞");
            put("亥酉", "灾煞");
        }
    };

    /**
     * 孤辰（年支+其余地支为键）
     */
    public static final Map<String, String> GU_CHEN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支查其余地支】子见'寅'。丑见'寅'。寅见'巳'。卯见'巳'。辰见'巳'。巳见'申'。午见'申'。未见'申'。申见'亥'。酉见'亥'。戌见'亥'。亥见'寅'

            二、详解：
                年支是子，并且其余地支有寅
                年支是丑，并且其余地支有寅
                年支是寅，并且其余地支有巳
                年支是卯，并且其余地支有巳
                年支是辰，并且其余地支有巳
                年支是巳，并且其余地支有申
                年支是午，并且其余地支有申
                年支是未，并且其余地支有申
                年支是申，并且其余地支有亥
                年支是酉，并且其余地支有亥
                年支是戌，并且其余地支有亥
                年支是亥，并且其余地支有寅
         */
        {
            put("子寅", "孤辰");
            put("丑寅", "孤辰");
            put("寅巳", "孤辰");
            put("卯巳", "孤辰");
            put("辰巳", "孤辰");
            put("巳申", "孤辰");
            put("午申", "孤辰");
            put("未申", "孤辰");
            put("申亥", "孤辰");
            put("酉亥", "孤辰");
            put("戌亥", "孤辰");
            put("亥寅", "孤辰");
        }
    };

    /**
     * 寡宿（年支+其余地支为键）
     */
    public static final Map<String, String> SU_GUA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支查其余地支】子见'戌'。丑见'戌'。寅见'丑'。卯见'丑'。辰见'丑'。巳见'辰'。午见'辰'。未见'辰'。申见'未'。酉见'未'。戌见'未'。亥见'戌'

            二、详解：
                年支是子，并且其余地支有戌
                年支是丑，并且其余地支有戌
                年支是寅，并且其余地支有丑
                年支是卯，并且其余地支有丑
                年支是辰，并且其余地支有丑
                年支是巳，并且其余地支有辰
                年支是午，并且其余地支有辰
                年支是未，并且其余地支有辰
                年支是申，并且其余地支有未
                年支是酉，并且其余地支有未
                年支是戌，并且其余地支有未
                年支是亥，并且其余地支有戌
         */
        {
            put("子戌", "寡宿");
            put("丑戌", "寡宿");
            put("寅丑", "寡宿");
            put("卯丑", "寡宿");
            put("辰丑", "寡宿");
            put("巳辰", "寡宿");
            put("午辰", "寡宿");
            put("未辰", "寡宿");
            put("申未", "寡宿");
            put("酉未", "寡宿");
            put("戌未", "寡宿");
            put("亥戌", "寡宿");
        }
    };

    /**
     * 元辰（年支+其余地支），阳男阴女
     */
    public static final Map<String, String> YUAN_CHEN_YANG_NAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支查其余地支】子见'未'。丑见'申'。寅见'酉'。卯见'戌'。辰见'亥'。巳见'子'。午见'丑'。未见'寅'。申见'卯'。酉见'辰'。戌见'巳'。亥见'午'

            二、详解：
                年支是子，并且其余地支有未
                年支是丑，并且其余地支有申
                年支是寅，并且其余地支有酉
                年支是卯，并且其余地支有戌
                年支是辰，并且其余地支有亥
                年支是巳，并且其余地支有子
                年支是午，并且其余地支有丑
                年支是未，并且其余地支有寅
                年支是申，并且其余地支有卯
                年支是酉，并且其余地支有辰
                年支是戌，并且其余地支有巳
                年支是亥，并且其余地支有午
         */
        {
            put("子未", "元辰");
            put("丑申", "元辰");
            put("寅酉", "元辰");
            put("卯戌", "元辰");
            put("辰亥", "元辰");
            put("巳子", "元辰");
            put("午丑", "元辰");
            put("未寅", "元辰");
            put("申卯", "元辰");
            put("酉辰", "元辰");
            put("戌巳", "元辰");
            put("亥午", "元辰");
        }
    };

    /**
     * 元辰（年支+其余地支），阴男阳女
     */
    public static final Map<String, String> YUAN_CHEN_YIN_NAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支查其余地支】子见'巳'。丑见'午'。寅见'未'。卯见'申'。辰见'酉'。巳见'戌'。午见'亥'。未见'子'。申见'丑'。酉见'寅'。戌见'卯'。亥见'辰'

            二、详解：
                年支是子，并且其余地支有巳
                年支是丑，并且其余地支有午
                年支是寅，并且其余地支有未
                年支是卯，并且其余地支有申
                年支是辰，并且其余地支有酉
                年支是巳，并且其余地支有戌
                年支是午，并且其余地支有亥
                年支是未，并且其余地支有子
                年支是申，并且其余地支有丑
                年支是酉，并且其余地支有寅
                年支是戌，并且其余地支有卯
                年支是亥，并且其余地支有辰
         */
        {
            put("子巳", "元辰");
            put("丑午", "元辰");
            put("寅未", "元辰");
            put("卯申", "元辰");
            put("辰酉", "元辰");
            put("巳戌", "元辰");
            put("午亥", "元辰");
            put("未子", "元辰");
            put("申丑", "元辰");
            put("酉寅", "元辰");
            put("戌卯", "元辰");
            put("亥辰", "元辰");
        }
    };

    /**
     * 血刃（月支+其余地支为键）
     */
    public static final Map<String, String> XUE_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以月支查其余地支】子见'午'。丑见'子'。寅见'丑'。卯见'未'。辰见'寅'。巳见'申'。午见'卯'。未见'酉'。申见'辰'。酉见'戌'。戌见'巳'。亥见'亥'

            二、详解：
                月支是子，并且其余地支有午
                月支是丑，并且其余地支有子
                月支是寅，并且其余地支有丑
                月支是卯，并且其余地支有未
                月支是辰，并且其余地支有寅
                月支是巳，并且其余地支有申
                月支是午，并且其余地支有卯
                月支是未，并且其余地支有酉
                月支是申，并且其余地支有辰
                月支是酉，并且其余地支有戌
                月支是戌，并且其余地支有巳
                月支是亥，并且其余地支有亥
         */
        {
            put("子午", "血刃");
            put("丑子", "血刃");
            put("寅丑", "血刃");
            put("卯未", "血刃");
            put("辰寅", "血刃");
            put("巳申", "血刃");
            put("午卯", "血刃");
            put("未酉", "血刃");
            put("申辰", "血刃");
            put("酉戌", "血刃");
            put("戌巳", "血刃");
            put("亥亥", "血刃");
        }
    };

    /**
     * 天医（月支+其余地支为键）
     */
    public static final Map<String, String> TIAN_YI = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以月支查其余地支】子见'亥'。丑见'子'。寅见'丑'。卯见'寅'。辰见'卯'。巳见'辰'。午见'巳'。未见'午'。申见'未'。酉见'申'。戌见'酉'。亥见'戌'

            二、详解：
                月支是子，并且其余地支有亥
                月支是丑，并且其余地支有子
                月支是寅，并且其余地支有丑
                月支是卯，并且其余地支有寅
                月支是辰，并且其余地支有卯
                月支是巳，并且其余地支有辰
                月支是午，并且其余地支有巳
                月支是未，并且其余地支有午
                月支是申，并且其余地支有未
                月支是酉，并且其余地支有申
                月支是戌，并且其余地支有酉
                月支是亥，并且其余地支有戌
         */
        {
            put("子亥", "天医");
            put("丑亥", "天医");
            put("寅亥", "天医");
            put("卯亥", "天医");
            put("辰亥", "天医");
            put("巳亥", "天医");
            put("午亥", "天医");
            put("未亥", "天医");
            put("申亥", "天医");
            put("酉亥", "天医");
            put("戌亥", "天医");
            put("亥亥", "天医");
        }
    };

    /**
     * 词馆（年柱纳音五行+月支\日支\时支为键），禄命法
     */
    public static final Map<String, String> CI_GUAN_LU_MING = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年柱纳音五行查月支\日支\时支】木见'寅'。火见'巳'。土见'亥'。金见'申'。水见'亥'

            二、详解：
                年柱纳音五行是木，并且月支\日支\时支有寅（庚寅为正词馆）
                年柱纳音五行是火，并且月支\日支\时支有巳（乙巳为正词馆）
                年柱纳音五行是土，并且月支\日支\时支有亥（丁亥为正词馆）
                年柱纳音五行是金，并且月支\日支\时支有申（壬申为正词馆）
                年柱纳音五行是水，并且月支\日支\时支有亥（癸亥为正词馆）
         */
        {
            put("木寅", "词馆");
            put("火巳", "词馆");
            put("土亥", "词馆");
            put("金申", "词馆");
            put("水亥", "词馆");
        }
    };

    /**
     * 词馆（年干\日干+其余天干或地支为键），子平法
     */
    public static final Map<String, String> CI_GUAN_ZI_PING = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年干\日干查其余天干或地支】甲见'己\亥'。乙见'壬\午'。丙见'丙\寅'。丁见'丁\酉'。戊见'戊\寅'。己见'己\酉'。庚见'辛\巳'。辛见'甲\子'。壬见'甲\申'。癸见'乙\卯'

            二、详解：
                年干\日干是甲，并且其余天干或地支有己\亥
                年干\日干是乙，并且其余天干或地支有壬\午
                年干\日干是丙，并且其余天干或地支有丙\寅
                年干\日干是丁，并且其余天干或地支有丁\酉
                年干\日干是戊，并且其余天干或地支有戊\寅
                年干\日干是己，并且其余天干或地支有己\酉
                年干\日干是庚，并且其余天干或地支有辛\巳
                年干\日干是辛，并且其余天干或地支有甲\子
                年干\日干是壬，并且其余天干或地支有甲\申
                年干\日干是癸，并且其余天干或地支有乙\卯
         */
        {
            put("甲己", "词馆");
            put("甲亥", "词馆");
            put("乙壬", "词馆");
            put("乙午", "词馆");
            put("丙丙", "词馆");
            put("丙寅", "词馆");
            put("丁丁", "词馆");
            put("丁酉", "词馆");
            put("戊戊", "词馆");
            put("戊寅", "词馆");
            put("己己", "词馆");
            put("己酉", "词馆");
            put("庚辛", "词馆");
            put("庚巳", "词馆");
            put("辛甲", "词馆");
            put("辛子", "词馆");
            put("壬甲", "词馆");
            put("壬申", "词馆");
            put("癸乙", "词馆");
            put("癸卯", "词馆");
        }
    };

    /**
     * 学堂（年柱纳音五行+月支\日支\时支为键），禄命法
     */
    public static final Map<String, String> XUE_TANG_LU_MING = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年柱纳音五行查月支\日支\时支】木见'亥'。火见'寅'。土见'申'。金见'巳'。水见'申'

            二、详解：
                年柱纳音五行是木，并且月支\日支\时支有亥（己亥为正学堂）
                年柱纳音五行是火，并且月支\日支\时支有寅（丙寅为正学堂）
                年柱纳音五行是土，并且月支\日支\时支有申（戊申为正学堂）
                年柱纳音五行是金，并且月支\日支\时支有巳（辛巳为正学堂）
                年柱纳音五行是水，并且月支\日支\时支有申（甲申为正学堂）
         */
        {
            put("木亥", "学堂");
            put("火寅", "学堂");
            put("土申", "学堂");
            put("金巳", "学堂");
            put("水申", "学堂");
        }
    };

    /**
     * 学堂（年干\日干+其余天干或地支为键），子平法
     */
    public static final Map<String, String> XUE_TANG_ZI_PING = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年干\日干查其余天干或地支】甲见'己\亥'。乙见'壬\午'。丙见'丙\寅'。丁见'丁\酉'。戊见'戊\寅'。己见'己\酉'。庚见'辛\巳'。辛见'甲\子'。壬见'甲\申'。癸见'乙\卯'

            二、详解：
                年干\日干是甲，并且其余天干或地支有己\亥
                年干\日干是乙，并且其余天干或地支有壬\午
                年干\日干是丙，并且其余天干或地支有丙\寅
                年干\日干是丁，并且其余天干或地支有丁\酉
                年干\日干是戊，并且其余天干或地支有戊\寅
                年干\日干是己，并且其余天干或地支有己\酉
                年干\日干是庚，并且其余天干或地支有辛\巳
                年干\日干是辛，并且其余天干或地支有甲\子
                年干\日干是壬，并且其余天干或地支有甲\申
                年干\日干是癸，并且其余天干或地支有乙\卯
         */
        {
            put("甲己", "学堂");
            put("甲亥", "学堂");
            put("乙壬", "学堂");
            put("乙午", "学堂");
            put("丙丙", "学堂");
            put("丙寅", "学堂");
            put("丁丁", "学堂");
            put("丁酉", "学堂");
            put("戊戊", "学堂");
            put("戊寅", "学堂");
            put("己己", "学堂");
            put("己酉", "学堂");
            put("庚辛", "学堂");
            put("庚巳", "学堂");
            put("辛甲", "学堂");
            put("辛子", "学堂");
            put("壬甲", "学堂");
            put("壬申", "学堂");
            put("癸乙", "学堂");
            put("癸卯", "学堂");
        }
    };

    /**
     * 天赦（月支+日干支为键）
     */
    public static final Map<String, String> TIAN_SHE = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以月支查日干支】子见'甲子'。丑见'甲子'。寅见'戊寅'。卯见'戊寅'。辰见'戊寅'。巳见'甲午'。午见'甲午'。未见'甲午'。申见'戊申'。酉见'戊申'。戌见'戊申'。亥见'甲子'

            二、详解：
                月支是子，并且日干支有甲子
                月支是丑，并且日干支有甲子
                月支是寅，并且日干支有戊寅
                月支是卯，并且日干支有戊寅
                月支是辰，并且日干支有戊寅
                月支是巳，并且日干支有甲午
                月支是午，并且日干支有甲午
                月支是未，并且日干支有甲午
                月支是申，并且日干支有戊申
                月支是酉，并且日干支有戊申
                月支是戌，并且日干支有戊申
                月支是亥，并且日干支有甲子
         */
        {
            put("子甲子", "天赦");
            put("丑甲子", "天赦");
            put("寅戊寅", "天赦");
            put("卯戊寅", "天赦");
            put("辰戊寅", "天赦");
            put("巳甲午", "天赦");
            put("午甲午", "天赦");
            put("未甲午", "天赦");
            put("申戊申", "天赦");
            put("酉戊申", "天赦");
            put("戌戊申", "天赦");
            put("亥甲子", "天赦");
        }
    };

    /**
     * 天转（月支+日干支为键）
     */
    public static final Map<String, String> TIAN_ZHUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以月支查日干支】子见'壬子'。丑见'壬子'。寅见'乙卯'。卯见'乙卯'。辰见'乙卯'。巳见'丙午'。午见'丙午'。未见'丙午'。申见'辛酉'。酉见'辛酉'。戌见'辛酉'。亥见'壬子'

            二、详解：
                月支是子，并且日干支有壬子
                月支是丑，并且日干支有壬子
                月支是寅，并且日干支有乙卯
                月支是卯，并且日干支有乙卯
                月支是辰，并且日干支有乙卯
                月支是巳，并且日干支有丙午
                月支是午，并且日干支有丙午
                月支是未，并且日干支有丙午
                月支是申，并且日干支有辛酉
                月支是酉，并且日干支有辛酉
                月支是戌，并且日干支有辛酉
                月支是亥，并且日干支有壬子
         */
        {
            put("子壬子", "天转");
            put("丑壬子", "天转");
            put("寅乙卯", "天转");
            put("卯乙卯", "天转");
            put("辰乙卯", "天转");
            put("巳丙午", "天转");
            put("午丙午", "天转");
            put("未丙午", "天转");
            put("申辛酉", "天转");
            put("酉辛酉", "天转");
            put("戌辛酉", "天转");
            put("亥壬子", "天转");
        }
    };

    /**
     * 地转（月支+日干支为键）
     */
    public static final Map<String, String> DI_ZHUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以月支查日干支】子见'丙子'。丑见'丙子'。寅见'辛卯'。卯见'辛卯'。辰见'辛卯'。巳见'戊午'。午见'戊午'。未见'戊午'。申见癸酉''。酉见'癸酉'。戌见'癸酉'。亥见'丙子'

            二、详解：
                月支是子，并且日干支有丙子
                月支是丑，并且日干支有丙子
                月支是寅，并且日干支有辛卯
                月支是卯，并且日干支有辛卯
                月支是辰，并且日干支有辛卯
                月支是巳，并且日干支有戊午
                月支是午，并且日干支有戊午
                月支是未，并且日干支有戊午
                月支是申，并且日干支有癸酉
                月支是酉，并且日干支有癸酉
                月支是戌，并且日干支有癸酉
                月支是亥，并且日干支有丙子
         */
        {
            put("子丙子", "地转");
            put("丑丙子", "地转");
            put("寅辛卯", "地转");
            put("卯辛卯", "地转");
            put("辰辛卯", "地转");
            put("巳戊午", "地转");
            put("午戊午", "地转");
            put("未戊午", "地转");
            put("申癸酉", "地转");
            put("酉癸酉", "地转");
            put("戌癸酉", "地转");
            put("亥丙子", "地转");
        }
    };

    /**
     * 月德贵人（月支+四柱天干为键）
     */
    public static final Map<String, String> YUE_DE_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以月支查四柱天干】子见'壬'。丑见'庚'。寅见'丙'。卯见'甲'。辰见'壬'。巳见'庚'。午见'丙'。未见'甲'。申见'壬'。酉见'庚'。戌见'丙'。亥见'甲'

            二、详解：
                月支是子，并且四柱天干有壬
                月支是丑，并且四柱天干有庚
                月支是寅，并且四柱天干有丙
                月支是卯，并且四柱天干有甲
                月支是辰，并且四柱天干有壬
                月支是巳，并且四柱天干有庚
                月支是午，并且四柱天干有丙
                月支是未，并且四柱天干有甲
                月支是申，并且四柱天干有壬
                月支是酉，并且四柱天干有庚
                月支是戌，并且四柱天干有丙
                月支是亥，并且四柱天干有甲
         */
        {
            put("子壬", "月德贵人");
            put("丑庚", "月德贵人");
            put("寅丙", "月德贵人");
            put("卯甲", "月德贵人");
            put("辰壬", "月德贵人");
            put("巳庚", "月德贵人");
            put("午丙", "月德贵人");
            put("未甲", "月德贵人");
            put("申壬", "月德贵人");
            put("酉庚", "月德贵人");
            put("戌丙", "月德贵人");
            put("亥甲", "月德贵人");
        }
    };

    /**
     * 德秀贵人（月支+四柱天干为键）
     */
    public static final Map<String, String> DE_XIU_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以月支查四柱天干】子见''。丑见''。寅见''。卯见''。辰见''。巳见''。午见''。未见''。申见''。酉见''。戌见''。亥见''

            二、详解：
                月支是子，并且四柱天干有甲\丙\戊\己\辛\壬\癸
                月支是丑，并且四柱天干有乙\庚\辛
                月支是寅，并且四柱天干有丙\丁\戊\癸
                月支是卯，并且四柱天干有甲\乙\丁\壬
                月支是辰，并且四柱天干有甲\丙\戊\己\辛\壬\癸
                月支是巳，并且四柱天干有乙\庚\辛
                月支是午，并且四柱天干有丙\丁\戊\癸
                月支是未，并且四柱天干有甲\乙\丁\壬
                月支是申，并且四柱天干有甲\丙\戊\己\辛\壬\癸
                月支是酉，并且四柱天干有乙\庚\辛
                月支是戌，并且四柱天干有丙\丁\戊\癸
                月支是亥，并且四柱天干有甲\乙\丁\壬'
         */
        {
            put("子甲", "德秀贵人");
            put("子丙", "德秀贵人");
            put("子戊", "德秀贵人");
            put("子己", "德秀贵人");
            put("子辛", "德秀贵人");
            put("子壬", "德秀贵人");
            put("子癸", "德秀贵人");
            put("丑乙", "德秀贵人");
            put("丑庚", "德秀贵人");
            put("丑辛", "德秀贵人");
            put("寅丙", "德秀贵人");
            put("寅丁", "德秀贵人");
            put("寅戊", "德秀贵人");
            put("寅癸", "德秀贵人");
            put("卯甲", "德秀贵人");
            put("卯乙", "德秀贵人");
            put("卯丁", "德秀贵人");
            put("卯壬", "德秀贵人");
            put("辰甲", "德秀贵人");
            put("辰丙", "德秀贵人");
            put("辰戊", "德秀贵人");
            put("辰己", "德秀贵人");
            put("辰辛", "德秀贵人");
            put("辰壬", "德秀贵人");
            put("辰癸", "德秀贵人");
            put("巳乙", "德秀贵人");
            put("巳庚", "德秀贵人");
            put("巳辛", "德秀贵人");
            put("午丙", "德秀贵人");
            put("午丁", "德秀贵人");
            put("午戊", "德秀贵人");
            put("午癸", "德秀贵人");
            put("未甲", "德秀贵人");
            put("未乙", "德秀贵人");
            put("未丁", "德秀贵人");
            put("未壬", "德秀贵人");
            put("申甲", "德秀贵人");
            put("申丙", "德秀贵人");
            put("申戊", "德秀贵人");
            put("申己", "德秀贵人");
            put("申辛", "德秀贵人");
            put("申壬", "德秀贵人");
            put("申癸", "德秀贵人");
            put("酉乙", "德秀贵人");
            put("酉庚", "德秀贵人");
            put("酉辛", "德秀贵人");
            put("戌丙", "德秀贵人");
            put("戌丁", "德秀贵人");
            put("戌戊", "德秀贵人");
            put("戌癸", "德秀贵人");
            put("亥甲", "德秀贵人");
            put("亥乙", "德秀贵人");
            put("亥丁", "德秀贵人");
            put("亥壬", "德秀贵人");
        }
    };

    /**
     * 天德贵人（月支+四柱天干\其余地支为键）
     */
    public static final Map<String, String> TIAN_DE_GUI_REN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以月支查四柱天干\其余地支】子见'巳'。丑见'庚'。寅见'丁'。卯见'申'。辰见'壬'。巳见'辛'。午见'亥'。未见'甲'。申见'癸'。酉见'寅'。戌见'丙'。亥见'乙'

            二、详解：
                月支是子，并且其余地支有巳
                月支是丑，并且四柱天干有庚
                月支是寅，并且四柱天干有丁
                月支是卯，并且其余地支有申
                月支是辰，并且四柱天干有壬
                月支是巳，并且四柱天干有辛
                月支是午，并且其余地支有亥
                月支是未，并且四柱天干有甲
                月支是申，并且四柱天干有癸
                月支是酉，并且其余地支有寅
                月支是戌，并且四柱天干有丙
                月支是亥，并且四柱天干有乙
         */
        {
            put("子巳", "天德贵人");
            put("丑庚", "天德贵人");
            put("寅丁", "天德贵人");
            put("卯申", "天德贵人");
            put("辰壬", "天德贵人");
            put("巳辛", "天德贵人");
            put("午亥", "天德贵人");
            put("未甲", "天德贵人");
            put("申癸", "天德贵人");
            put("酉寅", "天德贵人");
            put("戌丙", "天德贵人");
            put("亥乙", "天德贵人");
        }
    };

    /**
     * 拱禄（日干支+时干支+其余地支为键）
     */
    public static final Map<String, String> GONG_LU = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以日干支+时干支查其余地支】日癸亥时癸丑见'子'。日癸丑时癸亥见'子'。日丁巳时丁未见'午'。日己未时己巳见'午'。日戊辰时戊午见'巳'

            二、详解：
                日干支是癸亥，时干支是癸丑，并且其余地支有子
                日干支是癸丑，时干支是癸亥，并且其余地支有子
                日干支是丁巳，时干支是丁未，并且其余地支有午
                日干支是己未，时干支是己巳，并且其余地支有午
                日干支是戊辰，时干支是戊午，并且其余地支有巳
         */
        {
            put("癸亥癸丑子", "拱禄");
            put("癸丑癸亥子", "拱禄");
            put("丁巳丁未午", "拱禄");
            put("己未己巳午", "拱禄");
            put("戊辰戊午巳", "拱禄");
        }
    };

    /**
     * 华盖（年支\日支+其余地支为键）
     */
    public static final Map<String, String> HUA_GAI = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以年支\日支查其余地支】子见'辰'。丑见'丑'。寅见'戌'。卯见'未'。辰见'辰'。巳见'丑'。午见'戌'。未见'未'。申见'辰'。酉见'丑'。戌见'戌'。亥见'未'

            二、详解：
                年支\日支是子，并且其余地支有辰
                年支\日支是丑，并且其余地支有丑
                年支\日支是寅，并且其余地支有戌
                年支\日支是卯，并且其余地支有未
                年支\日支是辰，并且其余地支有辰
                年支\日支是巳，并且其余地支有丑
                年支\日支是午，并且其余地支有戌
                年支\日支是未，并且其余地支有未
                年支\日支是申，并且其余地支有辰
                年支\日支是酉，并且其余地支有丑
                年支\日支是戌，并且其余地支有戌
                年支\日支是亥，并且其余地支有未
         */
        {
            put("子辰", "华盖");
            put("丑丑", "华盖");
            put("寅戌", "华盖");
            put("卯未", "华盖");
            put("辰辰", "华盖");
            put("巳丑", "华盖");
            put("午戌", "华盖");
            put("未未", "华盖");
            put("申辰", "华盖");
            put("酉丑", "华盖");
            put("戌戌", "华盖");
            put("亥未", "华盖");
        }
    };

    /**
     * 童子煞（季节+日支\时支为键。年柱纳音五行+日支\时支为键）
     */
    public static final Map<String, String> TONG_ZI_SHA = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以季节查日支\时支】春季见'寅\子'。夏季见'卯\未\辰'。秋季见'寅\子'。冬季见'卯\未\辰'。木见'午\卯'。火见'酉\戌'。土见'辰\巳'。金见'午\卯'。水见'酉\戌'

            二、详解：
                春季，并且日支\时支有寅\子
                夏季，并且日支\时支有卯\未\辰
                秋季，并且日支\时支有寅\子
                冬季，并且日支\时支有卯\未\辰
                年柱纳音五行为木，并且日支\时支有午\卯
                年柱纳音五行为火，并且日支\时支有酉\戌
                年柱纳音五行为土，并且日支\时支有辰\巳
                年柱纳音五行为金，并且日支\时支有午\卯
                年柱纳音五行为水，并且日支\时支有酉\戌
         */
        {
            put("春寅", "童子煞");
            put("春子", "童子煞");
            put("秋寅", "童子煞");
            put("秋子", "童子煞");
            put("木午", "童子煞");
            put("木卯", "童子煞");
            put("金午", "童子煞");
            put("金卯", "童子煞");
            put("水酉", "童子煞");
            put("水戌", "童子煞");
            put("火酉", "童子煞");
            put("火戌", "童子煞");
            put("土辰", "童子煞");
            put("土巳", "童子煞");
        }
    };

    /**
     * 四废日（季节+日干支为键）
     */
    public static final Map<String, String> SI_FEI_RI = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        /*
            一、略解：
                【以季节查日干支】春季见'庚申\辛酉'。夏季见'壬子\癸亥'。秋季见'甲寅\乙卯'。冬季见'丙午\丁巳'。

            二、详解：
                春季，并且日干支有庚申\辛酉
                夏季，并且日干支有壬子\癸亥
                秋季，并且日干支有甲寅\乙卯
                冬季，并且日干支有丙午\丁巳
         */
        {
            put("春庚申", "四废日");
            put("春辛酉", "四废日");
            put("夏壬子", "四废日");
            put("夏癸亥", "四废日");
            put("秋甲寅", "四废日");
            put("秋乙卯", "四废日");
            put("冬丙午", "四废日");
            put("冬丁巳", "四废日");
        }
    };

    /**
     * 六甲空亡（年干支\日干支+四柱地支为键）
     */
    public static final Map<String, String> LIU_JIA_KONG_WANG = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        {
            put("甲子戌", "六甲空亡");
            put("乙丑戌", "六甲空亡");
            put("丙寅戌", "六甲空亡");
            put("丁卯戌", "六甲空亡");
            put("戊辰戌", "六甲空亡");
            put("己巳戌", "六甲空亡");
            put("庚午戌", "六甲空亡");
            put("辛未戌", "六甲空亡");
            put("壬申戌", "六甲空亡");
            put("癸酉戌", "六甲空亡");
            put("甲子亥", "六甲空亡");
            put("乙丑亥", "六甲空亡");
            put("丙寅亥", "六甲空亡");
            put("丁卯亥", "六甲空亡");
            put("戊辰亥", "六甲空亡");
            put("己巳亥", "六甲空亡");
            put("庚午亥", "六甲空亡");
            put("辛未亥", "六甲空亡");
            put("壬申亥", "六甲空亡");
            put("癸酉亥", "六甲空亡");
            put("甲戌申", "六甲空亡");
            put("乙亥申", "六甲空亡");
            put("丙子申", "六甲空亡");
            put("丁丑申", "六甲空亡");
            put("戊寅申", "六甲空亡");
            put("己卯申", "六甲空亡");
            put("庚辰申", "六甲空亡");
            put("辛巳申", "六甲空亡");
            put("壬午申", "六甲空亡");
            put("癸未申", "六甲空亡");
            put("甲戌酉", "六甲空亡");
            put("乙亥酉", "六甲空亡");
            put("丙子酉", "六甲空亡");
            put("丁丑酉", "六甲空亡");
            put("戊寅酉", "六甲空亡");
            put("己卯酉", "六甲空亡");
            put("庚辰酉", "六甲空亡");
            put("辛巳酉", "六甲空亡");
            put("壬午酉", "六甲空亡");
            put("癸未酉", "六甲空亡");
            put("甲申午", "六甲空亡");
            put("乙酉午", "六甲空亡");
            put("丙戌午", "六甲空亡");
            put("丁亥午", "六甲空亡");
            put("戊子午", "六甲空亡");
            put("己丑午", "六甲空亡");
            put("庚寅午", "六甲空亡");
            put("辛卯午", "六甲空亡");
            put("壬辰午", "六甲空亡");
            put("癸巳午", "六甲空亡");
            put("甲申未", "六甲空亡");
            put("乙酉未", "六甲空亡");
            put("丙戌未", "六甲空亡");
            put("丁亥未", "六甲空亡");
            put("戊子未", "六甲空亡");
            put("己丑未", "六甲空亡");
            put("庚寅未", "六甲空亡");
            put("辛卯未", "六甲空亡");
            put("壬辰未", "六甲空亡");
            put("癸巳未", "六甲空亡");
            put("甲午辰", "六甲空亡");
            put("乙未辰", "六甲空亡");
            put("丙申辰", "六甲空亡");
            put("丁酉辰", "六甲空亡");
            put("戊戌辰", "六甲空亡");
            put("己亥辰", "六甲空亡");
            put("庚子辰", "六甲空亡");
            put("辛丑辰", "六甲空亡");
            put("壬寅辰", "六甲空亡");
            put("癸卯辰", "六甲空亡");
            put("甲午巳", "六甲空亡");
            put("乙未巳", "六甲空亡");
            put("丙申巳", "六甲空亡");
            put("丁酉巳", "六甲空亡");
            put("戊戌巳", "六甲空亡");
            put("己亥巳", "六甲空亡");
            put("庚子巳", "六甲空亡");
            put("辛丑巳", "六甲空亡");
            put("壬寅巳", "六甲空亡");
            put("癸卯巳", "六甲空亡");
            put("甲辰寅", "六甲空亡");
            put("乙巳寅", "六甲空亡");
            put("丙午寅", "六甲空亡");
            put("丁未寅", "六甲空亡");
            put("戊申寅", "六甲空亡");
            put("己酉寅", "六甲空亡");
            put("庚戌寅", "六甲空亡");
            put("辛亥寅", "六甲空亡");
            put("壬子寅", "六甲空亡");
            put("癸丑寅", "六甲空亡");
            put("甲辰卯", "六甲空亡");
            put("乙巳卯", "六甲空亡");
            put("丙午卯", "六甲空亡");
            put("丁未卯", "六甲空亡");
            put("戊申卯", "六甲空亡");
            put("己酉卯", "六甲空亡");
            put("庚戌卯", "六甲空亡");
            put("辛亥卯", "六甲空亡");
            put("壬子卯", "六甲空亡");
            put("癸丑卯", "六甲空亡");
            put("甲寅子", "六甲空亡");
            put("乙卯子", "六甲空亡");
            put("丙辰子", "六甲空亡");
            put("丁巳子", "六甲空亡");
            put("戊午子", "六甲空亡");
            put("己未子", "六甲空亡");
            put("庚申子", "六甲空亡");
            put("辛酉子", "六甲空亡");
            put("壬戌子", "六甲空亡");
            put("癸亥子", "六甲空亡");
            put("甲寅丑", "六甲空亡");
            put("乙卯丑", "六甲空亡");
            put("丙辰丑", "六甲空亡");
            put("丁巳丑", "六甲空亡");
            put("戊午丑", "六甲空亡");
            put("己未丑", "六甲空亡");
            put("庚申丑", "六甲空亡");
            put("辛酉丑", "六甲空亡");
            put("壬戌丑", "六甲空亡");
            put("癸亥丑", "六甲空亡");
        }
    };

    /**
     * 截路空亡（日干+时支为键）
     */
    public static final Map<String, String> JIE_LU_KONG_WANG = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        {
            put("甲申", "截路空亡");
            put("甲酉", "截路空亡");
            put("乙午", "截路空亡");
            put("乙未", "截路空亡");
            put("丙辰", "截路空亡");
            put("丙巳", "截路空亡");
            put("丁寅", "截路空亡");
            put("丁卯", "截路空亡");
            put("戊子", "截路空亡");
            put("戊丑", "截路空亡");
            put("己申", "截路空亡");
            put("己酉", "截路空亡");
            put("庚午", "截路空亡");
            put("庚未", "截路空亡");
            put("辛辰", "截路空亡");
            put("辛巳", "截路空亡");
            put("壬寅", "截路空亡");
            put("壬卯", "截路空亡");
            put("癸子", "截路空亡");
            put("癸丑", "截路空亡");
        }
    };

    /**
     * 天罗地网（年支\日支+其余三支为键）
     */
    public static final Map<String, String> TIAN_LUO_DI_WANG = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        {
            put("戌亥", "天罗");
            put("亥戌", "天罗");
            put("辰巳", "地网");
            put("巳辰", "地网");
        }
    };

    /**
     * 阴注阳受（月支+其余地支为键）
     */
    public static final Map<String, String> YIN_ZHU_YANG_SHOU = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        {
            put("子子", "阴注阳受");
            put("丑亥", "阴注阳受");
            put("寅戌", "阴注阳受");
            put("卯酉", "阴注阳受");
            put("辰戌", "阴注阳受");
            put("巳亥", "阴注阳受");
            put("午子", "阴注阳受");
            put("未丑", "阴注阳受");
            put("申寅", "阴注阳受");
            put("酉卯", "阴注阳受");
            put("戌寅", "阴注阳受");
            put("亥丑", "阴注阳受");
        }
    };

    /**
     * 六厄（年支+其余地支为键）
     */
    public static final Map<String, String> LIU_E = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;
        {
            put("子卯", "六厄");
            put("丑子", "六厄");
            put("寅酉", "六厄");
            put("卯午", "六厄");
            put("辰卯", "六厄");
            put("巳子", "六厄");
            put("午酉", "六厄");
            put("未午", "六厄");
            put("申卯", "六厄");
            put("酉子", "六厄");
            put("戌酉", "六厄");
            put("亥午", "六厄");
        }
    };

    /**
     * 十恶大败（日干支）
     */
    public static final String[] SHI_E_DA_BAI = {"甲辰", "乙巳", "丙申", "丁亥", "戊戌", "己丑", "庚辰", "辛巳", "壬申", "癸亥"};

    /**
     * 阴差阳错（日干支）
     */
    public static final String[] YIN_CHA_YANG_CUO = {"丙午", "丙子", "丁未", "丁丑", "戊申", "戊寅", "辛酉", "辛卯", "壬戌", "壬辰", "癸巳", "癸亥"};

    /**
     * 孤鸾煞（日干支）
     */
    public static final String[] GU_LUAN_SHA = {"甲寅", "乙巳", "丙午", "丁巳", "戊午", "戊申", "辛亥", "壬子"};

    /**
     * 六秀日（日干支）
     */
    public static final String[] LIU_XIU_RI = {"丙午", "丁未", "戊子", "戊午", "己丑", "己未"};

    /**
     * 十灵日（日干支）
     */
    public static final String[] SHI_LING_RI = {"甲辰", "乙亥", "丙辰", "丁酉", "戊午", "庚戌", "庚寅", "辛亥", "壬寅", "癸未"};

    /**
     * 魁罡日（日干支）
     */
    public static final String[] KUI_GANG_RI = {"戊戌", "庚辰", "庚戌", "壬辰"};

    /**
     * 八专日（日干支）
     */
    public static final String[] BA_ZHUAN_RI = {"甲寅", "乙卯", "丁未", "戊戌", "己未", "庚申", "辛酉", "癸丑"};

    /**
     * 九丑日（日干支）
     */
    public static final String[] JIU_CHOU_RI = {"丁酉", "戊子", "戊午", "己卯", "己酉", "辛卯", "辛酉", "壬子", "壬午"};

    /**
     * 金神（日干支\时干支）
     */
    public static final String[] JIN_SHEN = {"乙丑", "己巳", "癸酉"};

//************************************************************************************************************************************

    // 小儿关煞

    /**
     * 劫煞关（年支+月支为键）
     */
    public static final Map<String, String> JIE_SHA_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子巳", "劫煞关");
            put("丑寅", "劫煞关");
            put("寅亥", "劫煞关");
            put("卯申", "劫煞关");
            put("辰巳", "劫煞关");
            put("巳寅", "劫煞关");
            put("午亥", "劫煞关");
            put("未申", "劫煞关");
            put("申巳", "劫煞关");
            put("酉寅", "劫煞关");
            put("戌亥", "劫煞关");
            put("亥申", "劫煞关");
        }
    };

    /**
     * 咸池关（年支+月支为键）
     */
    public static final Map<String, String> XIAN_CHI_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子酉", "咸池关");
            put("丑午", "咸池关");
            put("寅卯", "咸池关");
            put("卯子", "咸池关");
            put("辰酉", "咸池关");
            put("巳午", "咸池关");
            put("午卯", "咸池关");
            put("未子", "咸池关");
            put("申酉", "咸池关");
            put("酉午", "咸池关");
            put("戌卯", "咸池关");
            put("亥子", "咸池关");
        }
    };

    /**
     * 汤火关（年支+时支为键）
     */
    public static final Map<String, String> TANG_HUO_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子午", "汤火关");
            put("丑未", "汤火关");
            put("寅寅", "汤火关");
            put("卯午", "汤火关");
            put("辰未", "汤火关");
            put("巳寅", "汤火关");
            put("午午", "汤火关");
            put("未未", "汤火关");
            put("申寅", "汤火关");
            put("酉午", "汤火关");
            put("戌未", "汤火关");
            put("亥寅", "汤火关");
        }
    };

    /**
     * 短命关（年支+时支为键）
     */
    public static final Map<String, String> DUAN_MING_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子巳", "短命关");
            put("丑寅", "短命关");
            put("寅辰", "短命关");
            put("卯未", "短命关");
            put("辰巳", "短命关");
            put("巳寅", "短命关");
            put("午辰", "短命关");
            put("未未", "短命关");
            put("申巳", "短命关");
            put("酉寅", "短命关");
//            put("戌辰", "短命关");
//            put("亥未", "短命关");
        }
    };

    /**
     * 鬼门关（年支+时支为键）
     */
    public static final Map<String, String> GUI_MEN_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子酉", "鬼门关");
            put("丑午", "鬼门关");
            put("寅未", "鬼门关");
            put("卯申", "鬼门关");
            put("辰亥", "鬼门关");
            put("巳戌", "鬼门关");
            put("午丑", "鬼门关");
            put("未寅", "鬼门关");
            put("申卯", "鬼门关");
            put("酉子", "鬼门关");
            put("戌巳", "鬼门关");
            put("亥辰", "鬼门关");
        }
    };

    /**
     * 撞命关（年支+时支为键）
     */
    public static final Map<String, String> ZHUANG_MING_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子卯", "撞命关");
            put("丑未", "撞命关");
            put("寅巳", "撞命关");
            put("卯子", "撞命关");
            put("辰午", "撞命关");
            put("巳午", "撞命关");
            put("午辰", "撞命关");
            put("未丑", "撞命关");
            put("申午", "撞命关");
            put("酉亥", "撞命关");
            put("戌未", "撞命关");
            put("亥酉", "撞命关");
        }
    };

    /**
     * 埋儿关（年支+时支为键）
     */
    public static final Map<String, String> MAI_ER_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子丑", "埋儿关");
            put("丑卯", "埋儿关");
            put("寅申", "埋儿关");
            put("卯丑", "埋儿关");
            put("辰卯", "埋儿关");
            put("巳申", "埋儿关");
            put("午丑", "埋儿关");
            put("未卯", "埋儿关");
            put("申申", "埋儿关");
            put("酉丑", "埋儿关");
            put("戌卯", "埋儿关");
            put("亥申", "埋儿关");
        }
    };

    /**
     * 五鬼关（年支+时支为键）
     */
    public static final Map<String, String> WU_GUI_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子辰", "五鬼关");
            put("丑巳", "五鬼关");
            put("寅午", "五鬼关");
            put("卯未", "五鬼关");
            put("辰申", "五鬼关");
            put("巳酉", "五鬼关");
            put("午戌", "五鬼关");
            put("未亥", "五鬼关");
            put("申子", "五鬼关");
            put("酉丑", "五鬼关");
            put("戌寅", "五鬼关");
            put("亥卯", "五鬼关");
        }
    };

    /**
     * 天狗关（年支+时支为键）
     */
    public static final Map<String, String> TIAN_GOU_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子戌", "天狗关");
            put("丑亥", "天狗关");
            put("寅子", "天狗关");
            put("卯丑", "天狗关");
            put("辰寅", "天狗关");
            put("巳卯", "天狗关");
            put("午辰", "天狗关");
            put("未巳", "天狗关");
            put("申午", "天狗关");
            put("酉未", "天狗关");
            put("戌申", "天狗关");
            put("亥酉", "天狗关");
        }
    };

    /**
     * 天吊关（年支+时支为键）
     */
    public static final Map<String, String> TIAN_DIAO_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子巳", "天吊关");
            put("丑子", "天吊关");
            put("寅辰", "天吊关");
            put("卯申", "天吊关");
            put("辰巳", "天吊关");
            put("巳子", "天吊关");
            put("午辰", "天吊关");
            put("未申", "天吊关");
            put("申巳", "天吊关");
            put("酉子", "天吊关");
            put("戌辰", "天吊关");
            put("亥申", "天吊关");
            put("子午", "天吊关");
            put("丑卯", "天吊关");
            put("寅午", "天吊关");
            put("卯午", "天吊关");
            put("辰午", "天吊关");
            put("巳卯", "天吊关");
            put("午午", "天吊关");
            put("未午", "天吊关");
            put("申午", "天吊关");
            put("酉卯", "天吊关");
            put("戌午", "天吊关");
            put("亥午", "天吊关");
        }
    };

    /**
     * 休庵关（年支+时支为键）
     */
    public static final Map<String, String> XIU_AN_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子辰", "休庵关");
            put("丑子", "休庵关");
            put("寅寅", "休庵关");
            put("卯辰", "休庵关");
            put("辰子", "休庵关");
            put("巳寅", "休庵关");
            put("午辰", "休庵关");
            put("未子", "休庵关");
            put("申寅", "休庵关");
            put("酉辰", "休庵关");
            put("戌子", "休庵关");
            put("亥寅", "休庵关");
            put("子戌", "休庵关");
            put("丑午", "休庵关");
            put("寅申", "休庵关");
            put("卯戌", "休庵关");
            put("辰午", "休庵关");
            put("巳申", "休庵关");
            put("午戌", "休庵关");
            put("未午", "休庵关");
            put("申申", "休庵关");
            put("酉戌", "休庵关");
            put("戌午", "休庵关");
            put("亥申", "休庵关");
            put("子丑", "休庵关");
            put("丑卯", "休庵关");
            put("寅巳", "休庵关");
            put("卯丑", "休庵关");
            put("辰卯", "休庵关");
            put("巳巳", "休庵关");
            put("午丑", "休庵关");
            put("未卯", "休庵关");
            put("申巳", "休庵关");
            put("酉丑", "休庵关");
            put("戌卯", "休庵关");
            put("亥巳", "休庵关");
            put("子未", "休庵关");
            put("丑酉", "休庵关");
            put("寅亥", "休庵关");
            put("卯未", "休庵关");
            put("辰酉", "休庵关");
            put("巳亥", "休庵关");
            put("午未", "休庵关");
            put("未酉", "休庵关");
            put("申亥", "休庵关");
            put("酉未", "休庵关");
            put("戌酉", "休庵关");
            put("亥亥", "休庵关");
        }
    };

    /**
     * 百日关（月支+时支为键）
     */
    public static final Map<String, String> BAI_RI_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子寅", "百日关");
            put("丑子", "百日关");
            put("寅辰", "百日关");
            put("卯寅", "百日关");
            put("辰子", "百日关");
            put("巳辰", "百日关");
            put("午寅", "百日关");
            put("未子", "百日关");
            put("申辰", "百日关");
            put("酉寅", "百日关");
            put("戌子", "百日关");
            put("亥辰", "百日关");
            put("子申", "百日关");
            put("丑午", "百日关");
            put("寅戌", "百日关");
            put("卯申", "百日关");
            put("辰午", "百日关");
            put("巳戌", "百日关");
            put("午申", "百日关");
            put("未午", "百日关");
            put("申戌", "百日关");
            put("酉申", "百日关");
            put("戌午", "百日关");
            put("亥戌", "百日关");
            put("子巳", "百日关");
            put("丑卯", "百日关");
            put("寅丑", "百日关");
            put("卯巳", "百日关");
            put("辰卯", "百日关");
            put("巳丑", "百日关");
            put("午巳", "百日关");
            put("未卯", "百日关");
            put("申丑", "百日关");
            put("酉巳", "百日关");
            put("戌卯", "百日关");
            put("亥丑", "百日关");
            put("子亥", "百日关");
            put("丑酉", "百日关");
            put("寅未", "百日关");
            put("卯亥", "百日关");
            put("辰酉", "百日关");
            put("巳未", "百日关");
            put("午亥", "百日关");
            put("未酉", "百日关");
            put("申未", "百日关");
            put("酉亥", "百日关");
            put("戌酉", "百日关");
            put("亥未", "百日关");
        }
    };

    /**
     * 金锁关（月支+时支为键）
     */
    public static final Map<String, String> JIN_SUO_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子子", "金锁关");
            put("丑丑", "金锁关");
            put("寅申", "金锁关");
            put("卯酉", "金锁关");
            put("辰戌", "金锁关");
            put("巳亥", "金锁关");
            put("午子", "金锁关");
            put("未丑", "金锁关");
            put("申申", "金锁关");
            put("酉酉", "金锁关");
            put("戌戌", "金锁关");
            put("亥亥", "金锁关");
        }
    };

    /**
     * 夜啼关（月支+时支为键）
     */
    public static final Map<String, String> YE_TI_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子卯", "夜啼关");
            put("丑卯", "夜啼关");
            put("寅午", "夜啼关");
            put("卯午", "夜啼关");
            put("辰午", "夜啼关");
            put("巳酉", "夜啼关");
            put("午酉", "夜啼关");
            put("未酉", "夜啼关");
            put("申子", "夜啼关");
            put("酉子", "夜啼关");
            put("戌子", "夜啼关");
            put("亥卯", "夜啼关");
        }
    };

    /**
     * 浴盆关（月支+时支为键）
     */
    public static final Map<String, String> YU_PEN_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子丑", "浴盆关");
            put("丑丑", "浴盆关");
            put("寅辰", "浴盆关");
            put("卯辰", "浴盆关");
            put("辰辰", "浴盆关");
            put("巳未", "浴盆关");
            put("午未", "浴盆关");
            put("未未", "浴盆关");
            put("申戌", "浴盆关");
            put("酉戌", "浴盆关");
            put("戌戌", "浴盆关");
            put("亥丑", "浴盆关");
        }
    };

    /**
     * 四柱关（月支+时支为键）
     */
    public static final Map<String, String> SI_ZHU_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子丑", "四柱关");
            put("丑子", "四柱关");
            put("寅巳", "四柱关");
            put("卯辰", "四柱关");
            put("辰卯", "四柱关");
            put("巳寅", "四柱关");
            put("午丑", "四柱关");
            put("未子", "四柱关");
            put("申巳", "四柱关");
            put("酉辰", "四柱关");
            put("戌卯", "四柱关");
            put("亥寅", "四柱关");
            put("子未", "四柱关");
            put("丑午", "四柱关");
            put("寅亥", "四柱关");
            put("卯戌", "四柱关");
            put("辰酉", "四柱关");
            put("巳申", "四柱关");
            put("午未", "四柱关");
            put("未午", "四柱关");
            put("申亥", "四柱关");
            put("酉戌", "四柱关");
            put("戌酉", "四柱关");
            put("亥申", "四柱关");
        }
    };

    /**
     * 四季关（月支+时支为键）
     */
    public static final Map<String, String> SI_JI_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子寅", "四季关");
            put("丑寅", "四季关");
            put("寅巳", "四季关");
            put("卯巳", "四季关");
            put("辰巳", "四季关");
            put("巳辰", "四季关");
            put("午辰", "四季关");
            put("未辰", "四季关");
            put("申亥", "四季关");
            put("酉亥", "四季关");
            put("戌亥", "四季关");
            put("亥寅", "四季关");
            put("子戌", "四季关");
            put("丑戌", "四季关");
            put("寅丑", "四季关");
            put("卯丑", "四季关");
            put("辰丑", "四季关");
            put("巳申", "四季关");
            put("午申", "四季关");
            put("未申", "四季关");
            put("申未", "四季关");
            put("酉未", "四季关");
            put("戌未", "四季关");
            put("亥戌", "四季关");
        }
    };

    /**
     * 阎王关（月支+时支为键）
     */
    public static final Map<String, String> YAN_WANG_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子", "阎王关");
            put("丑", "阎王关");
            put("寅", "阎王关");
            put("卯", "阎王关");
            put("辰", "阎王关");
            put("巳", "阎王关");
            put("午", "阎王关");
            put("未", "阎王关");
            put("申", "阎王关");
            put("酉", "阎王关");
            put("戌", "阎王关");
            put("亥", "阎王关");
        }
    };

    /**
     * 水火关（月支+时支为键）
     */
    public static final Map<String, String> SHUI_HUO_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子辰", "水火关");
            put("丑辰", "水火关");
            put("寅未", "水火关");
            put("卯未", "水火关");
            put("辰未", "水火关");
            put("巳丑", "水火关");
            put("午丑", "水火关");
            put("未丑", "水火关");
            put("申丑", "水火关");
            put("酉丑", "水火关");
            put("戌丑", "水火关");
            put("亥辰", "水火关");
            put("子未", "水火关");
            put("丑未", "水火关");
            put("寅戌", "水火关");
            put("卯戌", "水火关");
            put("辰戌", "水火关");
            put("巳辰", "水火关");
            put("午辰", "水火关");
            put("未辰", "水火关");
            put("申戌", "水火关");
            put("酉戌", "水火关");
            put("戌戌", "水火关");
            put("亥未", "水火关");
        }
    };

    /**
     * 深水关（月支+时支为键）
     */
    public static final Map<String, String> SHEN_SHUI_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子丑", "深水关");
            put("丑丑", "深水关");
            put("寅申", "深水关");
            put("卯申", "深水关");
            put("辰申", "深水关");
            put("巳未", "深水关");
            put("午未", "深水关");
            put("未未", "深水关");
            put("申酉", "深水关");
            put("酉酉", "深水关");
            put("戌酉", "深水关");
            put("亥丑", "深水关");
            put("寅寅", "深水关");
            put("卯寅", "深水关");
            put("辰寅", "深水关");
        }
    };

    /**
     * 无情关（月支+时支为键）
     */
    public static final Map<String, String> WU_QING_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子午", "无情关");
            put("丑午", "无情关");
            put("寅子", "无情关");
            put("卯子", "无情关");
            put("辰子", "无情关");
            put("巳巳", "无情关");
            put("午巳", "无情关");
            put("未巳", "无情关");
            put("申酉", "无情关");
            put("酉酉", "无情关");
            put("戌酉", "无情关");
            put("亥午", "无情关");
            put("子子", "无情关");
            put("丑子", "无情关");
            put("寅寅", "无情关");
            put("卯寅", "无情关");
            put("辰寅", "无情关");
            put("巳戌", "无情关");
            put("午戌", "无情关");
            put("未戌", "无情关");
            put("申申", "无情关");
            put("酉申", "无情关");
            put("戌申", "无情关");
            put("亥子", "无情关");
            put("寅酉", "无情关");
            put("卯酉", "无情关");
            put("辰酉", "无情关");
            put("巳亥", "无情关");
            put("午亥", "无情关");
            put("未亥", "无情关");
        }
    };

    /**
     * 急脚关（月支+时支为键）
     */
    public static final Map<String, String> JI_JIAO_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子辰", "急脚关");
            put("丑辰", "急脚关");
            put("寅子", "急脚关");
            put("卯子", "急脚关");
            put("辰子", "急脚关");
            put("巳卯", "急脚关");
            put("午卯", "急脚关");
            put("未卯", "急脚关");
            put("申寅", "急脚关");
            put("酉寅", "急脚关");
            put("戌寅", "急脚关");
            put("亥辰", "急脚关");
            put("子丑", "急脚关");
            put("丑丑", "急脚关");
            put("寅亥", "急脚关");
            put("卯亥", "急脚关");
            put("辰亥", "急脚关");
            put("巳未", "急脚关");
            put("午未", "急脚关");
            put("未未", "急脚关");
            put("申戌", "急脚关");
            put("酉戌", "急脚关");
            put("戌戌", "急脚关");
            put("亥丑", "急脚关");
        }
    };

    /**
     * 断桥关（月支+时支为键）
     */
    public static final Map<String, String> DUAN_QIAO_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子亥", "断桥关");
            put("丑子", "断桥关");
            put("寅寅", "断桥关");
            put("卯卯", "断桥关");
            put("辰申", "断桥关");
            put("巳丑", "断桥关");
            put("午戌", "断桥关");
            put("未酉", "断桥关");
            put("申辰", "断桥关");
            put("酉巳", "断桥关");
            put("戌午", "断桥关");
            put("亥未", "断桥关");
        }
    };

    /**
     * 直难关（月支+时支为键）
     */
    public static final Map<String, String> ZHI_NAN_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子辰", "直难关");
            put("子酉", "直难关");
            put("丑辰", "直难关");
            put("丑酉", "直难关");
            put("寅午", "直难关");
            put("卯午", "直难关");
            put("辰未", "直难关");
            put("巳未", "直难关");
            put("午卯", "直难关");
            put("午戌", "直难关");
            put("未卯", "直难关");
            put("未戌", "直难关");
            put("申巳", "直难关");
            put("申申", "直难关");
            put("酉巳", "直难关");
            put("酉申", "直难关");
            put("戌寅", "直难关");
            put("戌卯", "直难关");
            put("亥寅", "直难关");
            put("亥卯", "直难关");
        }
    };

    /**
     * 血刃关（月支+时支为键）
     */
    public static final Map<String, String> XUE_REN_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子午", "血刃关");
            put("丑子", "血刃关");
            put("寅丑", "血刃关");
            put("卯未", "血刃关");
            put("辰寅", "血刃关");
            put("巳申", "血刃关");
            put("午卯", "血刃关");
            put("未酉", "血刃关");
            put("申辰", "血刃关");
            put("酉戌", "血刃关");
            put("戌巳", "血刃关");
            put("亥亥", "血刃关");
        }
    };

    /**
     * 基败关（月支+时支为键）
     */
    public static final Map<String, String> JI_BAI_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子寅", "基败关");
            put("子卯", "基败关");
            put("子午", "基败关");
            put("丑寅", "基败关");
            put("丑卯", "基败关");
            put("丑午", "基败关");
            put("寅未", "基败关");
            put("寅戌", "基败关");
            put("寅亥", "基败关");
            put("卯未", "基败关");
            put("卯戌", "基败关");
            put("卯亥", "基败关");
            put("辰未", "基败关");
            put("辰戌", "基败关");
            put("辰亥", "基败关");
            put("巳子", "基败关");
            put("巳辰", "基败关");
            put("巳巳", "基败关");
            put("午子", "基败关");
            put("午辰", "基败关");
            put("午巳", "基败关");
            put("未子", "基败关");
            put("未辰", "基败关");
            put("未巳", "基败关");
            put("申丑", "基败关");
            put("申申", "基败关");
            put("申酉", "基败关");
            put("酉丑", "基败关");
            put("酉申", "基败关");
            put("酉酉", "基败关");
            put("戌丑", "基败关");
            put("戌申", "基败关");
            put("戌酉", "基败关");
            put("亥寅", "基败关");
            put("亥卯", "基败关");
            put("亥午", "基败关");
        }
    };

    /**
     * 水穴关（月支+时支为键）
     */
    public static final Map<String, String> SHUI_XUE_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子酉", "水穴关");
            put("丑丑", "水穴关");
            put("寅丑", "水穴关");
            put("卯丑", "水穴关");
            put("辰戌", "水穴关");
            put("辰未", "水穴关");
            put("巳戌", "水穴关");
            put("巳未", "水穴关");
            put("午戌", "水穴关");
            put("午未", "水穴关");
            put("未辰", "水穴关");
            put("未丑", "水穴关");
            put("申辰", "水穴关");
            put("申丑", "水穴关");
            put("酉辰", "水穴关");
            put("酉丑", "水穴关");
            put("戌酉", "水穴关");
            put("亥酉", "水穴关");
        }
    };

    /**
     * 将军箭（月支+时支为键）
     */
    public static final Map<String, String> JIANG_JUN_JIAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("子巳", "将军箭");
            put("丑巳", "将军箭");
            put("寅辰", "将军箭");
            put("卯辰", "将军箭");
            put("辰辰", "将军箭");
            put("巳子", "将军箭");
            put("午子", "将军箭");
            put("未子", "将军箭");
            put("申丑", "将军箭");
            put("酉丑", "将军箭");
            put("戌丑", "将军箭");
            put("亥巳", "将军箭");
            put("子申", "将军箭");
            put("丑申", "将军箭");
            put("寅酉", "将军箭");
            put("卯酉", "将军箭");
            put("辰酉", "将军箭");
            put("巳卯", "将军箭");
            put("午卯", "将军箭");
            put("未卯", "将军箭");
            put("申寅", "将军箭");
            put("酉寅", "将军箭");
            put("戌寅", "将军箭");
            put("亥申", "将军箭");
            put("子亥", "将军箭");
            put("丑亥", "将军箭");
            put("寅戌", "将军箭");
            put("卯戌", "将军箭");
            put("辰戌", "将军箭");
            put("巳未", "将军箭");
            put("午未", "将军箭");
            put("未未", "将军箭");
            put("申午", "将军箭");
            put("酉午", "将军箭");
            put("戌午", "将军箭");
            put("亥亥", "将军箭");
        }
    };

    /**
     * 白虎关（月支+时支为键）
     */
    public static final Map<String, String> BAI_HU_GUAN_MONTH_ZHI = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
//            put("子", "白虎关");
//            put("丑", "白虎关");
            put("寅申", "白虎关");
            put("寅酉", "白虎关");
            put("卯申", "白虎关");
            put("卯酉", "白虎关");
            put("辰戌", "白虎关");
            put("巳丑", "白虎关");
            put("巳卯", "白虎关");
            put("午丑", "白虎关");
            put("午卯", "白虎关");
            put("未丑", "白虎关");
            put("未卯", "白虎关");
//            put("申", "白虎关");
            put("酉卯", "白虎关");
//            put("戌", "白虎关");
            put("亥卯", "白虎关");
        }
    };

    /**
     * 白虎关（日干+时支为键）
     */
    public static final Map<String, String> BAI_HU_GUAN_DAY_GAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("甲酉", "白虎关");
            put("乙酉", "白虎关");
            put("丙子", "白虎关");
            put("丁子", "白虎关");
            put("戊午", "白虎关");
            put("己午", "白虎关");
            put("庚卯", "白虎关");
            put("辛卯", "白虎关");
            put("壬午", "白虎关");
            put("癸午", "白虎关");
        }
    };

    /**
     * 铁蛇关（年干+时支为键）
     */
    public static final Map<String, String> TIE_SHE_GUAN_YEAR = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("甲巳", "铁蛇关");
            put("甲酉", "铁蛇关");
            put("甲丑", "铁蛇关");
            put("乙申", "铁蛇关");
            put("乙子", "铁蛇关");
            put("乙辰", "铁蛇关");
            put("丙申", "铁蛇关");
            put("丙子", "铁蛇关");
            put("丙辰", "铁蛇关");
            put("丁申", "铁蛇关");
            put("丁子", "铁蛇关");
            put("丁辰", "铁蛇关");
            put("戊申", "铁蛇关");
            put("戊子", "铁蛇关");
            put("戊辰", "铁蛇关");
            put("己巳", "铁蛇关");
            put("己酉", "铁蛇关");
            put("己丑", "铁蛇关");
            put("庚亥", "铁蛇关");
            put("庚卯", "铁蛇关");
            put("庚未", "铁蛇关");
            put("辛亥", "铁蛇关");
            put("辛卯", "铁蛇关");
            put("辛未", "铁蛇关");
            put("壬寅", "铁蛇关");
            put("壬午", "铁蛇关");
            put("壬戌", "铁蛇关");
            put("癸寅", "铁蛇关");
            put("癸午", "铁蛇关");
            put("癸戌", "铁蛇关");
        }
    };

    /**
     * 铁蛇关（日干+时支为键）
     */
    public static final Map<String, String> TIE_SHE_GUAN_DAY = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("甲辰", "铁蛇关");
            put("乙辰", "铁蛇关");
            put("丙未", "铁蛇关");
            put("丁未", "铁蛇关");
            put("戊寅", "铁蛇关");
            put("己寅", "铁蛇关");
            put("庚戌", "铁蛇关");
            put("辛戌", "铁蛇关");
            put("壬丑", "铁蛇关");
            put("癸丑", "铁蛇关");
            put("丙申", "铁蛇关");
            put("丁申", "铁蛇关");
        }
    };

    /**
     * 鸡飞关（年干\日干+时支为键）
     */
    public static final Map<String, String> JI_FEI_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("甲巳", "鸡飞关");
            put("乙子", "鸡飞关");
            put("丙子", "鸡飞关");
            put("丁子", "鸡飞关");
            put("戊子", "鸡飞关");
            put("己巳", "鸡飞关");
            put("庚亥", "鸡飞关");
            put("辛亥", "鸡飞关");
            put("壬寅", "鸡飞关");
            put("癸寅", "鸡飞关");
            put("甲酉", "鸡飞关");
            put("己酉", "鸡飞关");
            put("庚卯", "鸡飞关");
            put("辛卯", "鸡飞关");
            put("壬午", "鸡飞关");
            put("癸午", "鸡飞关");
            put("甲丑", "鸡飞关");
            put("己丑", "鸡飞关");
            put("庚未", "鸡飞关");
            put("辛未", "鸡飞关");
            put("壬戌", "鸡飞关");
            put("癸戌", "鸡飞关");
        }
    };

    /**
     * 落井关（年干\日干+时支为键）
     */
    public static final Map<String, String> LUO_JING_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("甲巳", "落井关");
            put("乙子", "落井关");
            put("丙申", "落井关");
            put("丁戌", "落井关");
            put("戊卯", "落井关");
            put("己巳", "落井关");
            put("庚子", "落井关");
            put("辛申", "落井关");
            put("壬戌", "落井关");
            put("癸卯", "落井关");
        }
    };

    /**
     * 雷公关（年干\日干+时支为键）
     */
    public static final Map<String, String> LEI_GONG_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("甲丑", "雷公关");
            put("乙午", "雷公关");
            put("丙子", "雷公关");
            put("丁子", "雷公关");
            put("戊戌", "雷公关");
            put("己戌", "雷公关");
            put("庚寅", "雷公关");
            put("辛寅", "雷公关");
            put("壬酉", "雷公关");
            put("癸亥", "雷公关");
        }
    };

    /**
     * 千日关（年干\日干+时支为键）
     */
    public static final Map<String, String> QIAN_RI_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("甲午", "千日关");
            put("乙午", "千日关");
            put("丙申", "千日关");
            put("丁申", "千日关");
            put("戊巳", "千日关");
            put("己巳", "千日关");
            put("庚寅", "千日关");
            put("辛寅", "千日关");
            put("壬丑", "千日关");
            put("癸丑", "千日关");
            put("壬亥", "千日关");
            put("癸亥", "千日关");
        }
    };

    /**
     * 断肠关（年干\日干+时支为键）
     */
    public static final Map<String, String> DUAN_CHANG_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("甲午", "断肠关");
            put("乙午", "断肠关");
            put("丙辰", "断肠关");
            put("丁辰", "断肠关");
            put("庚寅", "断肠关");
            put("辛寅", "断肠关");
            put("壬丑", "断肠关");
            put("癸丑", "断肠关");
            put("甲未", "断肠关");
            put("乙未", "断肠关");
            put("丙巳", "断肠关");
            put("丁巳", "断肠关");
        }
    };

    /**
     * 取命关（年干\日干+时支为键）
     */
    public static final Map<String, String> QU_MING_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("甲申", "取命关");
            put("乙申", "取命关");
            put("丙申", "取命关");
            put("丁申", "取命关");
            put("戊亥", "取命关");
            put("己亥", "取命关");
            put("庚亥", "取命关");
            put("辛寅", "取命关");
            put("壬寅", "取命关");
            put("癸寅", "取命关");
            put("甲子", "取命关");
            put("乙子", "取命关");
            put("丙子", "取命关");
            put("丁子", "取命关");
            put("戊卯", "取命关");
            put("己卯", "取命关");
            put("庚卯", "取命关");
            put("辛午", "取命关");
            put("壬午", "取命关");
            put("癸午", "取命关");
            put("甲辰", "取命关");
            put("乙辰", "取命关");
            put("丙辰", "取命关");
            put("丁辰", "取命关");
            put("戊未", "取命关");
            put("己未", "取命关");
            put("庚未", "取命关");
            put("辛戌", "取命关");
            put("壬戌", "取命关");
            put("癸戌", "取命关");
        }
    };

    /**
     * 多厄关（年干支纳音五行+月支+性别为键）
     */
    public static final Map<String, String> DUO_E_GUAN = new HashMap<String, String>() {
        private static final long serialVersionUID = -1;

        {
            put("木卯男", "多厄关");
            put("木辰男", "多厄关");
            put("火子男", "多厄关");
            put("火丑男", "多厄关");
            put("土寅男", "多厄关");
            put("土巳男", "多厄关");
            put("金午男", "多厄关");
            put("金未男", "多厄关");
            put("水酉男", "多厄关");
            put("水戌男", "多厄关");
            put("木子女", "多厄关");
            put("木丑女", "多厄关");
            put("火午女", "多厄关");
            put("火未女", "多厄关");
            put("土寅女", "多厄关");
            put("土巳女", "多厄关");
            put("金酉女", "多厄关");
            put("金戌女", "多厄关");
            put("水卯女", "多厄关");
            put("水辰女", "多厄关");
        }
    };


}
